fields (version 5.02)

The Engines:: Basic linear algebra utilities and other computations supporting the Krig function.

Description

These are internal functions to Krig that compute the basic matrix decompositions or solve the linear systems needed to evaluate the Krig/Tps estimate. Others listed below do some simple housekeeping and formatting. Typically they are called from within Krig but can also be used directly if passed a Krig object list.

Usage

Krig.engine.default(out, verbose = FALSE)
Krig.engine.knots(out, verbose = FALSE)
Krig.engine.fixed( out, verbose=FALSE, lambda=NA)
Krig.coef(out, lambda = out$lambda, y = NULL, yM = NULL, verbose = FALSE) 
Krig.make.u(out, y = NULL, yM = NULL, verbose = FALSE) 
Krig.check.xY(x, Y,Z, weights, na.rm, verbose = FALSE) 
Krig.cor.Y(obj, verbose = FALSE) 
Krig.transform.xY(obj, knots, verbose = FALSE)
Krig.make.W( out, verbose=FALSE)
Krig.make.Wi ( out, verbose=FALSE)

Details

ENGINES:

The engines are the code modules that handle the basic linear algebra needed to computed the estimated curve or surface coefficients. All the engine work on the data that has been reduced to unique locations and possibly replicate group means with the weights adjusted accordingly. All information needed for the decomposition are components in the Krig object passed to these functions.

Krig.engine.default finds the decompositions for a Universal Kriging estimator. by simultaneously diagonalizing the linear system system for the coefficients of the estimator. The main advantage of this form is that it is fairly stable numerically, even with ill-conditioned covariance matrices with lambda > 0. (i.e. provided there is a "nugget" or measure measurement error. Also the eigendecomposition allows for rapid evaluation of the likelihood, GCV and coefficients for new data vectors under different values of the smoothing parameter, lambda.

Krig.engine.knots finds the decompositions in the case that the covariance is evaluated at arbitrary locations possibly different than the data locations (called knots). The intent of these decompositions is to facilitate the evaluation at different values for lambda. There will be computational savings when the number of knots is less than the number of unique locations. (But the knots are as densely distributed as the structure in the underlying spatial process.) This function call fields.diagonalize, a function that computes the matrix and eigenvalues that simultaneous diagonalize a nonnegative definite and a positive definite matrix. These decompositions also facilitate multiple evaluations of the likelihood and GCV functions in estimating a smoothing parameter and also multiple solutions for different y vectors.

Krig.engine.fixed are specific decomposition based on the Cholesky factorization assuming that the smoothing parameter is fixed. This is the only case that works in the sparse matrix. Both knots and the full set of locations can be handled by this case. The difference between the "knots" engine above is that only a single value of lambda is considered in the fixed engine.

OTHER FUNCTIONS:

Krig.coef Computes the "c" and "d" coefficients to represent the estimated curve. These coefficients are used by the predict functions for evaluations. Krig.coef can be used outside of the call to Krig to recompute the fit with different Y values and possibly with different lambda values. If new y values are not passed to this function then the yM vector in the Krig object is used. The internal function Krig.ynew sorts out the logic of what to do and use based on the passed arguments.

Krig.make.u Computes the "u" vector, a transformation of the collapsed observations that allows for rapid evaluation of the GCV function and prediction. This only makes sense when the decomposition is WBW or DR, i.e. an eigen decomposition. If the decompostion is the Cholesky based then this function returns NA for the u component in the list.

Krig.check.xY Checks for removes missing values (NAs).

Krig.cor.Y Standardizes the data vector Y based on a correlation model.

Krig.transform.xY Finds all replicates and collapse to unique locations and mean response and pooled variances and weights. These are the xM, yM and weightsM used in the engines. Also scales the x locations and the knots according to the transformation.

Krig.make.W and Krig.make.Wi These functions create an off-diagonal weight matrix and its symmetric square root or the inverse of the weight matrix based on the information passed to Krig. If out$nondiag is TRUE W is constructed based on a call to the passed function wght.function along with additional arguments. If this flag is FALSE then W is just diag(out$weightsM) and the square root and inverse are computed directly.

%d*% Is a simple way to implement efficient diagonal multiplications. x%d*%y is interpreted to mean diag(x)%*% y if x is a vector. If x is a matrix then this becomes the same as the usual matrix multiplication.

See Also

Krig, Tps

Examples

Krig( ozone$x, ozone$y)-> out

Krig.engine.default( out)-> stuff

# compare "stuff" to components in out$matrices

Krig.coef( out)$c
# compare to out$c

Krig.coef( out, yM = ozone$y)$c
# better be the same even though we pass as new data!